package com.jinmdz.fmis.api.admin.service;

import com.jinmdz.fmis.api.admin.model.goodsservice.*;
import com.jinmdz.fmis.api.api.model.common.IdData;
import com.jinmdz.fmis.api.api.model.common.IdVersionData;
import com.jinmdz.fmis.api.base.BaseService;
import com.jinmdz.fmis.api.model.config.dictionary.OperationLogCode;
import com.jinmdz.fmis.api.model.system.UserItem;
import com.jinmdz.fmis.api.wrapper.OperationWrapper;
import com.jinmdz.fmis.common.ext.StringBuilderExt;
import com.jinmdz.fmis.common.util.BeanUtil;
import com.jinmdz.fmis.common.util.DataUtil;
import com.jinmdz.fmis.common.util.third.Pinyin4jUtil;
import com.jinmdz.fmis.core.base.BaseResult;
import com.jinmdz.fmis.core.exception.ActionException;
import com.jinmdz.fmis.core.model.SearchLoadData;
import com.jinmdz.fmis.core.util.JacksonUtil;
import com.jinmdz.fmis.dao.admin.dao.GoodsServiceDao;
import com.jinmdz.fmis.dao.admin.model.goodsservice.*;
import com.jinmdz.fmis.mapper.entity.ServiceItemEntity;
import com.jinmdz.fmis.mapper.entity.ServicePackageItemEntity;
import com.jinmdz.fmis.mapper.entity.ServiceTypeEntity;
import com.jinmdz.fmis.mapper.mapper.ServiceItemMapper;
import com.jinmdz.fmis.mapper.mapper.ServicePackageItemMapper;
import com.jinmdz.fmis.mapper.mapper.ServiceTypeMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;

/**
 * 服务物品
 *
 * @author GuanKui
 * @date 2020/3/9 15:14
 */
@Service("goodsServiceService")
public class GoodsServiceService extends BaseService {

    @Resource
    private GoodsServiceDao goodsServiceDao;

    @Resource
    private ServiceTypeMapper serviceTypeMapper;

    @Resource
    private ServiceItemMapper serviceItemMapper;

    @Resource
    private ServicePackageItemMapper packageItemMapper;

    @Resource
    private OperationWrapper operationWrapper;

    @Resource
    private OperationLogCode operationLogCode;

    /**
     * 加载物品、服务类型基本信息
     *
     * @param
     * @return
     * @author GuanKui
     * @date 2020/3/9  15:08
     */
    public BaseResult<ArrayList<GoodsServiceTypeListItem>> loadGoodsServiceTypeList() {
        //获取物品服务分类
        ArrayList<GoodsServiceTypeListItem> loadItems = goodsServiceDao.listGoodsServiceTypeList();
        return successList(loadItems);
    }

    /**
     * 根据类型id加载物品、服务类型基本信息
     *
     * @param data 主键
     * @return
     * @author GuanKui
     * @date 2020/3/10 13:13
     */
    public BaseResult<GoodsServiceTypeSaveData> loadGoodsServiceTypeWithId(IdData data) {
        // 加载数据
        GoodsServiceTypeSaveData loadData = new GoodsServiceTypeSaveData();
        // 加载业务数据
        if (DataUtil.valid(data.getId())) {
            Integer loadId = data.getId();
            // 查询业务信息
            GoodsServiceTypeEditItem loadItem = goodsServiceDao.getGoodsServiceTypeEditById(loadId);
            if (DataUtil.isNull(loadItem) || DataUtil.isNull(loadItem.getId(), loadItem.getVersion())) {
                return failure("主键错误，不存在此服务类型信息");
            }
            loadData = BeanUtil.copy2Bean(loadItem, loadData);
        }
        return successData(loadData);
    }

    /**
     * 保存物品、服务类型基本信息
     *
     * @param userItem 当前账号
     * @param data     物品服务保存数据
     * @return
     * @author GuanKui
     * @date 2020/3/9  16:17
     */
    @Transactional(rollbackFor = Exception.class)
    public BaseResult saveGoodsServiceType(UserItem userItem, GoodsServiceTypeSaveData data) throws ActionException {
        Integer id = data.getId();
        // 主键不为空
        if (DataUtil.valid(id)) {
            updateGoodsServiceType(userItem, data);
        } else {
            id = insertGoodsServiceType(userItem, data);
        }
        return success("保存成功");
    }

    /**
     * 插入物品服务分类信息
     *
     * @param userItem 当前账号
     * @param data     物品服务保存数据
     * @return
     * @author LiCongLu
     * @date 2020-03-26 10:05
     */
    private Integer insertGoodsServiceType(UserItem userItem, GoodsServiceTypeSaveData data) throws ActionException {

        // 创建实体
        ServiceTypeEntity entity = getEntity(userItem, ServiceTypeEntity.class);

        // 覆盖数据
        BeanUtil.copy2Bean(data, entity);

        // 对物品分类信息进行判断处理
        checkGoodsServiceTypeValue(entity);

        //数据保存
        serviceTypeMapper.insertServiceType(entity);
        // 判断保存物品信息结果
        if (DataUtil.invalid(entity.getId())) {
            throw exception("保存物品服务分类信息失败");
        }

        // 添加日志
        saveGoodsServiceTypeLog(userItem, operationLogCode.getInsert(), data, null, entity);
        return entity.getId();
    }

    /**
     * 验证处理物品分类信息
     *
     * @param entity 服务品服务信息
     * @return
     * @author LiCongLu
     * @date 2020-03-26 10:07
     */
    private void checkGoodsServiceTypeValue(ServiceTypeEntity entity) throws ActionException {
        // 判断父主键
        if (DataUtil.isNull(entity.getParentId())) {
            entity.setParentId(0);
        }

        // 判断排序值
        if (DataUtil.isNull(entity.getSort())) {
            entity.setSort(0);
        }

        // 判断类型编码重复性
        Integer serviceTypeCodeId = goodsServiceDao.getGoodsServiceTypeIdByTypeCode(entity.getId(), entity.getTypeCode());
        if (DataUtil.valid(serviceTypeCodeId)) {
            throw exception("存在类型编码重复");
        }

        // 判断类型名称重复性
        Integer serviceTypeNameId = goodsServiceDao.getGoodsServiceTypeIdByTypeName(entity.getId(), entity.getTypeName());
        if (DataUtil.valid(serviceTypeNameId)) {
            throw exception("存在类型名称重复");
        }
    }

    /**
     * 添加修改记录: 保存物品、服务类型基本信息
     *
     * @param userItem    当前帐号
     * @param logTypeCode 操作日志值
     * @param data        请求数据
     * @param oldValue    旧数据
     * @param entity      保存实体
     * @param
     * @return
     * @author GuanKui
     * @date 2020/3/13  16:43
     */
    private void saveGoodsServiceTypeLog(UserItem userItem, Integer logTypeCode, GoodsServiceTypeSaveData data, String oldValue,
                                         ServiceTypeEntity entity) throws ActionException {
        // 操作日志字符串
        StringBuilderExt builder = new StringBuilderExt();
        builder.format("保存物品、服务类型信息，类型编码[{0}]，类型名称[{1}]，类型描述[{2}]，备注信息[{3}]，操作人员[{4}]"
                , data.getTypeCode(), data.getTypeName()
                , data.getTypeDescribe(), data.getRemark(), userItem.getFullName());

        // 添加日志
        operationWrapper.operationLog(userItem, logTypeCode, builder.toString(), JacksonUtil.obj2Json(data), oldValue, JacksonUtil.obj2Json(entity));
    }

    /**
     * 插入物品服务分类信息
     *
     * @param userItem 当前账号
     * @param data     物品服务保存数据
     * @return
     * @author LiCongLu
     * @date 2020-03-26 10:28
     */
    private void updateGoodsServiceType(UserItem userItem, GoodsServiceTypeSaveData data) throws ActionException {
        // 验证主键和数据版本是否存在
        if (DataUtil.isNull(data.getId(), data.getVersion())) {
            throw exception("请求类型主键与类型版本号不能为空");
        }

        // 根据id获取物品、服务类型基本信息
        ServiceTypeEntity entity = serviceTypeMapper.getServiceTypeById(data.getId());
        if (DataUtil.isNull(entity) || DataUtil.isNull(entity.getId(), entity.getVersion())) {
            throw exception("类型主键错误，不存在此类型信息");
        }

        // 验证信息版本
        if (!DataUtil.equals(data.getVersion(), entity.getVersion())) {
            throw exception(versionError("物品服务类型信息"));
        }

        // 记录旧数据
        String oldValue = JacksonUtil.obj2Json(entity);

        // 覆盖数据
        BeanUtil.copy2Bean(data, entity);

        // 对物品服务类型信息进行判断处理
        checkGoodsServiceTypeValue(entity);

        // 更新物品服务类型信息
        serviceTypeMapper.updateServiceType(entity);

        // 添加操作日志
        saveGoodsServiceTypeLog(userItem, operationLogCode.getUpdate(), data, oldValue, entity);
    }

    /**
     * 删除物品、服务类型基本信息
     *
     * @param userItem 当前账号
     * @param data     主键和数据版本
     * @return
     * @author GuanKui
     * @date 2020/3/9  17:11
     */
    @Transactional(rollbackFor = Exception.class)
    public BaseResult deleteGoodsServiceTypeWithId(UserItem userItem, ArrayList<IdVersionData> data) throws ActionException {
        // 判断删除主键集合是否存在
        if (DataUtil.invalid(data)) {
            throw exception("不存在要删除的服务类型信息");
        }

        // 验证主键是否重复
        if (data.size() != getRepeatIdSize(data)) {
            throw exception("服务类型主键存在重复");
        }

        // 记录字典数据集合
        ArrayList<GoodsServiceTypeEditItem> loadItems = new ArrayList();

        // 进行遍历删除信息
        for (IdVersionData idData : data) {
            // 根据id获取物品、服务类型基本信息
            GoodsServiceTypeEditItem loadItem = goodsServiceDao.getGoodsServiceTypeEditById(idData.getId());
            if (loadItem == null || DataUtil.isNull(loadItem.getId())) {
                throw exception("主键错误,不存在此服务类型基本信息");
            }

            // 验证服务类型信息版本
            if (!DataUtil.equals(loadItem.getVersion(), idData.getVersion())) {
                throw exception(versionError("服务类型信息"));
            }

            // 验证是否包含物品服务信息
            Integer serviceCount = goodsServiceDao.getServiceCountByTypeId(idData.getId());
            if (DataUtil.valid(serviceCount)) {
                throw exception("包含物品服务，不能删除");
            }

            //删除ServiceType
            serviceTypeMapper.deletedForServiceType(loadItem.getId(), userItem.getId(), loadItem.getVersion());

            // 记录类型信息
            loadItems.add(loadItem);
        }

        //添加删除日志
        deleteGoodsServiceTypeLog(userItem, operationLogCode.getDelete(), data, loadItems);

        return success("删除完成");

    }

    /**
     * 添加删除记录:删除物品、服务类型基本信息
     *
     * @param userItem    当前帐号
     * @param logTypeCode 操作日志值
     * @param data        请求数据
     * @param loadItems   旧数据
     * @return
     * @author GuanKui
     * @date 2020/3/13  16:15
     */
    private void deleteGoodsServiceTypeLog(UserItem userItem, Integer logTypeCode, ArrayList<IdVersionData> data, ArrayList<GoodsServiceTypeEditItem> loadItems) throws ActionException {
        // 操作日志字符串
        StringBuilderExt builder = new StringBuilderExt();
        builder.format("删除物品、服务类型信息，操作人员[{0}]", userItem.getFullName());
        // 添加日志
        operationWrapper.operationLog(userItem, operationLogCode.getDelete(), builder.toString(), JacksonUtil.obj2Json(data), JacksonUtil.obj2Json(loadItems), null);
    }

    /**
     * 根据类型加载物品、服务类型基本信息
     *
     * @param data 物品服务类型
     * @return
     * @author GuanKui
     * @date 2020/3/10 9:32
     */
    public BaseResult<SearchLoadData<GoodsServiceListItem>> loadGoodsServiceListWithType(GoodsServiceTypeData data) {
        startPageData(data);
        ArrayList<GoodsServiceListItem> loadItems = goodsServiceDao.listGoodsServiceListByTypeId(data.getServiceTypeId(), data.getKeyword());
        // 初始化返回实体
        SearchLoadData<GoodsServiceListItem> loadData = getSearchLoadData(loadItems);
        return successData(loadData);
    }

    /**
     * 加载不是任务包的物品、服务信息
     *
     * @param
     * @return
     * @author GuanKui
     * @date 2020/3/10 10:23
     */
    public BaseResult<ArrayList<GoodsServiceChildListItem>> loadGoodsServiceListNoPackage() {
        ArrayList<GoodsServiceListItem> listItems = goodsServiceDao.listGoodsServiceListNoPackage();
        ArrayList<GoodsServiceChildListItem> loadItems = BeanUtil.copy2List(listItems, GoodsServiceChildListItem.class);
        return successList(loadItems);
    }

    /**
     * 根据物品服务项目id，加载物品、服务基本信息
     *
     * @param data 主键
     * @return
     * @author GuanKui
     * @date 2020/3/10 13:23
     */
    public BaseResult<GoodsServiceLoadData> loadGoodsServiceWithId(IdData data) {
        // 返回数据
        GoodsServiceLoadData loadData = new GoodsServiceLoadData();

        // 加载数据
        if (DataUtil.valid(data.getId())) {
            // 根据id获取物品、服务类型基本信息
            GoodsServiceEditItem loadItem = goodsServiceDao.getGoodsServiceEditById(data.getId());
            if (DataUtil.isNull(loadItem) || DataUtil.isNull(loadItem.getId(), loadItem.getVersion())) {
                return failure("主键错误,不存在此服务项目信息");
            }
            // 设置返回数据
            loadData.setGoodsService(BeanUtil.copy2Bean(loadItem, new GoodsServiceSaveEditItem()));

            // 是否物品包
            if (DataUtil.valid(loadItem.getAsPackage())) {
                ArrayList<GoodsServicePackageListItem> packageListItems = goodsServiceDao.listGGoodsServicePackageListByPackageId(loadItem.getId());
                loadData.setServicePackageItems(BeanUtil.copy2List(packageListItems, GoodsServiceSavePackageItem.class));
            }
        }

        return successData(loadData);
    }

    /**
     * 保存物品、服务基本信息
     *
     * @param userItem 当前账号
     * @param data     保存数据
     * @return
     * @author GuanKui
     * @date 2020/3/10 10:47
     */
    @Transactional(rollbackFor = Exception.class)
    public BaseResult saveGoodsService(UserItem userItem, GoodsServiceSaveData data) throws ActionException {
        Integer id = data.getGoodsService().getId();
        // 主键不为空
        if (DataUtil.valid(id)) {
            updateGoodsService(userItem, data);
        } else {
            id = insertGoodsService(userItem, data);
        }
        return success("保存完成");
    }

    /**
     * 保存物品、服务基本信息
     *
     * @param userItem 当前账号
     * @param saveData 保存数据
     * @return
     * @author LiCongLu
     * @date 2020-03-26 14:39
     */
    private Integer insertGoodsService(UserItem userItem, GoodsServiceSaveData saveData) {
        GoodsServiceSaveEditItem data = saveData.getGoodsService();

        // 创建实体
        ServiceItemEntity entity = getEntity(userItem, ServiceItemEntity.class);

        // 覆盖数据
        BeanUtil.copy2Bean(data, entity);

        // 对物品信息进行判断处理
        checkGoodsServiceValue(entity);

        //数据保存
        serviceItemMapper.insertServiceItem(entity);
        // 判断保存物品信息结果
        if (DataUtil.invalid(entity.getId())) {
            throw exception("保存物品服务信息失败");
        }

        // 判断是否物品包
        if (DataUtil.valid(data.getAsPackage()) && DataUtil.valid(saveData.getGoodsServicePackage())) {
            saveGoodsServicePackage(userItem, entity.getId(), saveData.getGoodsServicePackage());
        }

        // 添加日志
        saveGoodsServiceLog(userItem, operationLogCode.getInsert(), data, null, entity);
        return entity.getId();
    }

    /**
     * 验证处理物品信息
     *
     * @param entity 服务品服务信息
     * @return
     * @author LiCongLu
     * @date 2020-03-26 14:44
     */
    private void checkGoodsServiceValue(ServiceItemEntity entity) throws ActionException {

        // 判断是否物品
        if (DataUtil.isNull(entity.getAsGoods())) {
            entity.setAsGoods(0);
        }

        // 判断是否项目包
        if (DataUtil.isNull(entity.getAsPackage())) {
            entity.setAsPackage(0);
        }

        // 判断是否固定价格
        if (DataUtil.isNull(entity.getAsFixPrice())) {
            entity.setAsFixPrice(0);
        }

        // 判断销售状态
        if (DataUtil.isNull(entity.getDisableState())) {
            entity.setDisableState(0);
        }

        // 判断排序值
        if (DataUtil.isNull(entity.getSort())) {
            entity.setSort(0);
        }

        // 设置简拼
        entity.setItemNameAbbr(Pinyin4jUtil.getPinyinAbbrToLowerCase(entity.getItemName()));

        // 判断项目编码重复性
        Integer itemCodeId = goodsServiceDao.getGoodsServiceIdByItemCode(entity.getId(), entity.getServiceTypeId(), entity.getItemCode());
        if (DataUtil.valid(itemCodeId)) {
            throw exception("存在物品服务编码重复");
        }

        // 判断项目名称重复性
        Integer itemNameId = goodsServiceDao.getGoodsServiceIdByItemName(entity.getId(), entity.getServiceTypeId(), entity.getItemName());
        if (DataUtil.valid(itemNameId)) {
            throw exception("存在物品服务名称重复");
        }
    }

    /**
     * 保存包明细
     *
     * @param userItem         当前账号
     * @param servicePackageId 物品包主键
     * @param serviceList      子物品集合
     * @return
     * @author LiCongLu
     * @date 2020-03-26 15:10
     */
    private void saveGoodsServicePackage(UserItem userItem, Integer servicePackageId, ArrayList<GoodsServiceSavePackageItem> serviceList) throws ActionException {
        // 存在子物品集合
        if (DataUtil.valid(serviceList)) {
            // 遍历插入关联信息
            for (GoodsServiceSavePackageItem saveItem : serviceList) {
                // 判断物品服务
                GoodsServiceEditItem loadItem = goodsServiceDao.getGoodsServiceEditById(saveItem.getServiceItemId());
                if (DataUtil.isNull(loadItem) || DataUtil.isNull(loadItem.getId(), loadItem.getVersion())) {
                    throw exception("物品服务主键错误,不存在此服务项目信息");
                }

                // 物品已停售，不能保存
                if (DataUtil.valid(loadItem.getDisableState())) {
                    throw exception("物品包存在停售物品");
                }

                // 插入关联信息
                ServicePackageItemEntity entity = getEntity(userItem, ServicePackageItemEntity.class);
                // 设置数据
                entity.setServicePackageId(servicePackageId)
                        .setServiceItemId(saveItem.getServiceItemId())
                        .setItemNumber(saveItem.getItemNumber())
                        .setItemPrice(loadItem.getItemPrice())
                        .setItemDescribe(loadItem.getItemDescribe())
                        .setRemark(loadItem.getRemark());

                //数据保存
                packageItemMapper.insertServicePackageItem(entity);
                // 判断关联物品结果
                if (DataUtil.invalid(entity.getId())) {
                    throw exception("添加物品包子物品失败");
                }
            }
        }
    }

    /**
     * 添加修改记录: 保存物品、服务基本信息（添加、修改）
     *
     * @param userItem    当前帐号
     * @param logTypeCode 操作日志值
     * @param data        请求数据
     * @param oldValue    旧数据
     * @param entity      保存实体
     * @param
     * @return
     * @author GuanKui
     * @date 2020/3/13  16:43
     */
    private void saveGoodsServiceLog(UserItem userItem, Integer logTypeCode, GoodsServiceSaveEditItem data, String oldValue,
                                     ServiceItemEntity entity) throws ActionException {
        // 操作日志字符串
        StringBuilderExt builder = new StringBuilderExt();
        builder.format("保存物品、服务基本信息，类型名称[{0}][{1}]，项目编码[{2}]，项目名称[{3}]，项目价格[{4}]，项目数量[{5}]，项目单位[{6}]，操作人员[{4}]"
                , String.valueOf(entity.getServiceTypeId()), data.getServiceTypeName()
                , data.getItemCode(), data.getItemName()
                , DataUtil.getPlainString(data.getItemPrice())
                , DataUtil.getPlainString(data.getItemNumber())
                , data.getItemUnit(), userItem.getFullName());

        // 添加日志
        operationWrapper.operationLog(userItem, logTypeCode, builder.toString(), JacksonUtil.obj2Json(data), oldValue, JacksonUtil.obj2Json(entity));
    }


    /**
     * 更新物品、服务基本信息
     *
     * @param userItem 当前账号
     * @param saveData 保存数据
     * @author LiCongLu
     * @date 2020-03-26 14:37
     */
    private void updateGoodsService(UserItem userItem, GoodsServiceSaveData saveData) throws ActionException {
        GoodsServiceSaveEditItem data = saveData.getGoodsService();

        // 验证主键和数据版本是否存在
        if (DataUtil.isNull(data.getId(), data.getVersion())) {
            throw exception("请求主键与版本号不能为空");
        }

        // 根据id获取物品、服务基本信息
        ServiceItemEntity entity = serviceItemMapper.getServiceItemById(data.getId());
        if (DataUtil.isNull(entity) || DataUtil.isNull(entity.getId(), entity.getVersion())) {
            throw exception("主键错误，不存在此物品服务信息");
        }

        // 验证信息版本
        if (!DataUtil.equals(data.getVersion(), entity.getVersion())) {
            throw exception(versionError("物品服务信息"));
        }

        // 记录旧数据
        String oldValue = JacksonUtil.obj2Json(entity);

        // 覆盖数据
        BeanUtil.copy2Bean(data, entity);

        // 对物品服务信息进行判断处理
        checkGoodsServiceValue(entity);

        // 更新物品服务信息
        serviceItemMapper.updateServiceItem(entity);

        // 添加操作日志
        saveGoodsServiceLog(userItem, operationLogCode.getUpdate(), data, oldValue, entity);

        // 根据service_item表id删除服务项目关联信息
        goodsServiceDao.deleteServicePackageForPackageId(entity.getId(), userItem.getId());

        // 判断是否物品包
        if (DataUtil.valid(data.getAsPackage()) && DataUtil.valid(saveData.getGoodsServicePackage())) {
            saveGoodsServicePackage(userItem, entity.getId(), saveData.getGoodsServicePackage());
        }

        // 添加日志
        saveGoodsServiceLog(userItem, operationLogCode.getInsert(), data, oldValue, entity);
    }

    /**
     * 删除服务项目
     *
     * @param userItem 当前账号
     * @param data     加载数据
     * @return
     * @author GuanKui
     * @date 2020/3/10 8:56
     */
    @Transactional(rollbackFor = Exception.class)
    public BaseResult deleteGoodsServiceWithId(UserItem userItem, ArrayList<IdVersionData> data) throws ActionException {
        // 判断参数是否有效
        if (DataUtil.invalid(data)) {
            throw exception("请选择删除信息");
        }

        // 验证主键是否重复
        if (data.size() != getRepeatIdSize(data)) {
            throw exception("物品服务主键存在重复");
        }

        // 记录字典数据集合
        ArrayList<GoodsServiceEditItem> loadItems = new ArrayList();

        for (IdVersionData idData : data) {
            // 根据id获取物品、服务类型基本信息
            GoodsServiceEditItem loadItem = goodsServiceDao.getGoodsServiceEditById(idData.getId());
            if (DataUtil.isNull(loadItem) || DataUtil.isNull(loadItem.getId(), loadItem.getVersion())) {
                throw exception("主键错误,不存在此服务项目信息");
            }

            // 验证服务类型信息版本
            if (!DataUtil.equals(loadItem.getVersion(), idData.getVersion())) {
                throw exception(versionError("服务项目信息"));
            }

            // 不是物品包时，检验是否被物品包使用
            if (DataUtil.invalid(loadItem.getAsPackage())) {
                Integer servicePackageId = goodsServiceDao.getServicePackageIdByServiceItemId(loadItem.getId());
                if (DataUtil.valid(servicePackageId)) {
                    throw exception("存在被包含的打包物品，无法删除");
                }
            } else {
                // 是物品包，删除其子物品关联信息
                goodsServiceDao.deleteServicePackageForPackageId(loadItem.getId(), userItem.getId());
            }

            //删除ServiceItem
            serviceItemMapper.deletedForServiceItem(loadItem.getId(), userItem.getId(), loadItem.getVersion());

            // 加载加载信息
            loadItems.add(loadItem);
        }
        //添加删除
        deleteGoodsServiceLog(userItem, operationLogCode.getDelete(), data, loadItems);
        return success("删除完成");
    }

    /**
     * 添加删除记录:删除服务项目
     *
     * @param userItem    当前帐号
     * @param logTypeCode 操作日志值
     * @param data        请求数据
     * @param loadItems   被删除数据
     * @return
     * @author GuanKui
     * @date 2020/3/13  16:15
     */
    private void deleteGoodsServiceLog(UserItem userItem, Integer logTypeCode, ArrayList<IdVersionData> data, ArrayList<GoodsServiceEditItem> loadItems) throws ActionException {
        // 操作日志字符串
        StringBuilderExt builder = new StringBuilderExt();
        builder.format("删除服务项目信息，操作人员[{0}]", userItem.getFullName());
        // 添加日志
        operationWrapper.operationLog(userItem, operationLogCode.getDelete(), builder.toString(), JacksonUtil.obj2Json(data), JacksonUtil.obj2Json(loadItems), null);
    }

    /**
     * 加载数据库表中所有的物品、服务信息
     *
     * @param
     * @return
     * @author GuanKui
     * @date 2020/3/17  10:41
     */
    public BaseResult<ArrayList<GoodsServiceListItem>> loadGoodsServiceList() {
        ArrayList<GoodsServiceListItem> loadItems = goodsServiceDao.listGoodsServiceListAsValid();
        return successList(loadItems);
    }
}
